{
LANG : PASCAL
PROB : rect1
}
Const
          fi = 'rect1.in';
          fo = 'rect1.out';
          Full  =     1 ;
          Stripe=     2 ;

Var       n     :     Integer ;
          ptd , ptc : Integer ;
          side  :     LongInt ;
          Wide,Long:  Integer ;
          A     :     array[1..1001,1..5] of Integer ;
          B , C :     array[1..2002]      of Integer ;
          L     :     array[1..2500]      of LongInt ;
          Total :     array[1..10000]     of ShortInt ;

Procedure SwapB( i , j : Integer ) ;
Var
     tg : Integer ;
Begin
     tg := B[i] ; B[i] := B[j] ; B[j] := tg ;
End ;

Procedure QuicksortB( l , r : Integer ) ;
Var
     Key , i , j : Integer ;
Begin
     If l >= r then Exit ;
     Key := B[ l + Random(r-l+1) ] ;
     i := l ; j := r ;
     While i < j do Begin
           While B[i] < Key do Inc(i) ;
           While B[j] > Key do Dec(j) ;
           If i <= j then Begin
              SwapB(i,j) ;
              Inc(i) ; Dec(j) ;
           End ;
     End ;
     QuicksortB(l,j) ; QuicksortB(i,r) ;
End ;


Procedure SwapC( i , j : Integer ) ;
Var
     tg : Integer ;
Begin
     tg := C[i] ; C[i] := C[j] ; C[j] := tg ;
End ;

Procedure QuicksortC( l , r : Integer ) ;
Var
     Key , i , j : Integer ;
Begin
     If l >= r then Exit ;
     Key := C[ l + Random(r-l+1) ] ;
     i := l ; j := r ;
     While i < j do Begin
           While C[i] < Key do Inc(i) ;
           While C[j] > Key do Dec(j) ;
           If i <= j then Begin
              SwapC(i,j) ;
              Inc(i) ; Dec(j) ;
           End ;
     End ;
     QuicksortC(l,j) ; QuicksortC(i,r) ;
End ;

Procedure Init ;
Var
     i , j : Integer ;
Begin
     For i := 1 to n do Begin
         Inc( ptc ) ; B[ptc] := A[i,1] ;
         Inc( ptc ) ; B[ptc] := A[i,3] ;
         Inc( ptd ) ; C[ptd] := A[i,2] ;
         Inc( ptd ) ; C[ptd] := A[i,4] ;
     End ;
     QuicksortB(1,ptc) ;
     j := 1 ;
     For i := 2 to ptc do
         If B[i] <> B[j] then Begin
            Inc(j) ; B[j] := B[i] ;
         End ;
     ptc := j ;

     QuicksortC(1,ptd) ;
     j := 1 ;
     For i := 2 to ptd do
         If C[i] <> C[j] then Begin
            Inc(j) ; C[j] := C[i] ;
         End ;
     ptd := j ;
End ;

Procedure Calculate( down , up , color : Integer ) ;

    Function Update( k , left , right : Integer ) : LongInt ;
    Var
         mid : Integer ;
         gt  : LongInt ;
    Begin
         If Total[k] = Full then Update := 0
         Else Begin
             If Total[k] = 0 then
                If ( down <= C[left] )and( C[right] <= up ) then Begin
                   Total[k] := Full ;
                   Update := C[right] - C[left] ; Exit ;
                End ;
             If left + 1 >= right then Begin
                Update := 0 ; Exit ;
             End ;
             mid := (left+right) shr 1 ;
             gt := 0 ;
             If down   < C[mid] then gt := gt + Update(k*2,left,mid)    ;
             If C[mid] < up     then gt := gt + Update(k*2+1,mid,right) ;
             If gt > 0 then Total[k] := Stripe ;
             Update := gt ;
         End ;
    End ;

Begin
     L[color] := L[color] + Update( 1 , 1 , ptd ) * side ;
End ;

Procedure Process ;
Var
     i , j : Integer ;
Begin
     For i := 1 to ptc - 1 do Begin
         Fillchar( Total , sizeof(Total) , 0 ) ;

         side := B[i+1] - B[i] ;
         For j := n downto 1 do
             If A[j,1] = B[i] then Begin
                Calculate( A[j,2] , A[j,4] , A[j,5] )    ;
                If A[j,3] > B[i+1] then A[j,1] := B[i+1] ;
             End ;
     End ;

     For i := 1 to 2500 do If L[i] > 0 then Writeln(i,' ',L[i]) ;
End ;

Procedure Nhapdl ;
Var
     i : Integer ;
Begin
     Read( Wide , Long , n ) ;
     Inc( n ) ;
     A[1,3] := Wide ;
     A[1,4] := Long ;
     A[1,5] := 1    ;
     For i := 2 to n do Read( A[i,1] , A[i,2] , A[i,3] , A[i,4] , A[i,5] ) ;
End ;

BEGIN
     assign(input, fi); reset(input);
     assign(output, fo); rewrite(output);
     Nhapdl  ;
     Init    ;
     Process ;
     close(output);
     close(input);
END.